﻿using System.Drawing;
using System.Globalization;
using System.IO;
using System.Web.Mvc;
using System.Web.Script.Serialization;
using ABC.Business.Models;
using ABC.Controllers.ViewModels.My;
using System.Collections.Generic;
using System;
using System.Linq;
using ABC.Domain.Entities;
using ABC.Domain.Serialization;
using ProgressBar.Framework;
using ABC.Domain.Json;
using iTextSharp.text;
using iTextSharp.text.pdf;
using iTextSharp.text.pdf.draw;
using Font = iTextSharp.text.Font;
using GDI = System.Drawing;
using Rectangle = iTextSharp.text.Rectangle;

namespace ABC.Controllers.Areas.My
{
    [Authorize]
    public class InformationController : BaseController
    {
        private readonly RbsCalcModel rbsCalcModel;
        private readonly RosModel rosModel;
        private readonly PdfModel pdfModel;
        private readonly CabinetModel cabinetModel;
        private readonly ClientsModel clientsModel;
        protected readonly ProgressManager ProgressManager;

        public String GetTaskId()
        {
            var id = Request.Headers[ProgressManager.HeaderNameTaskId];
            return id ?? String.Empty;
        }

        public String Status()
        {
            var taskId = GetTaskId();
            return ProgressManager.GetStatus(taskId);
        }

        public void Abort()
        {
            var taskId = GetTaskId();
            ProgressManager.RequestTermination(taskId);
        }
        public InformationController(RbsCalcModel rbsCalcModel, RosModel rosModel, PdfModel pdfModel, CabinetModel cabinetModel, ClientsModel clientsModel)
        {
            this.clientsModel = clientsModel;
            this.rbsCalcModel = rbsCalcModel;
            this.rosModel = rosModel;
            this.pdfModel = pdfModel;
            this.cabinetModel = cabinetModel;
            ProgressManager = new ProgressManager();
        }

        public ActionResult Contact()
        {
            return View();
        }
        public ActionResult Feed()
        {
            return View();
        }
        public ActionResult Messages()
        {
            return View();
        }
        public ActionResult Ratings()
        {
            return View();
        }
        public ActionResult Kasko(string id)
        {
            var model = new CalcKaskoViewModel();
            model.KaskoExpressData = "[]";
            model.ObjectData = "[]";
            if (TempData["kaskoexpressdata"] != null)
            {
                var kaskoExpressData = (KaskoExpress)TempData["kaskoexpressdata"];
                var serializer = new JavaScriptSerializer();
                model.KaskoExpressData = serializer.Serialize(kaskoExpressData);
            }
            if (TempData["objectdata"] != null)
            {
                model.ObjectData = TempData["objectdata"].ToString();
            }
            var resultsId = rosModel.GetEntityValue<string>(CurrentUser.Id, "ИсторияРасчетов").Split(new[] { ";" }, StringSplitOptions.RemoveEmptyEntries);
            foreach (var resultId in resultsId)
            {
                var kasko = rbsCalcModel.GetCalculationKasko(resultId);
                var fullResult = new FullResult
                {
                    Results = kasko.KaskoResults,
                    Id = resultId,
                    UniqueNumber = kasko.UniqueNumber,
                    IsSave = rosModel.GetEntityValue<bool>(resultId, "СохраненРасчет"),
                    DateTimeCalc =
                        rosModel.GetEntityValue<DateTime>(resultId, "ДатаСозданияОбъекта").ToString(
                            "от dd MMMM, HH:mm")
                };
                model.KaskoTables.Add(kasko);
                model.Results.Add(fullResult);
            }
            if (!string.IsNullOrEmpty(id))
            {
                if (!model.Results.Any(x => x.Id == id))
                {
                    var kasko = rbsCalcModel.GetCalculationKasko(id);
                    var fullResult = new FullResult
                    {
                        Results = kasko.KaskoResults,
                        Id = id,
                        UniqueNumber = kasko.UniqueNumber,
                        IsSave = rosModel.GetEntityValue<bool>(id, "СохраненРасчет"),
                        DateTimeCalc =
                            rosModel.GetEntityValue<DateTime>(id, "ДатаСозданияОбъекта").ToString(
                                "от dd MMMM, HH:mm")
                    };
                    model.KaskoTables.Add(kasko);
                    model.Results.Add(fullResult);
                }
                model.CurrentTabId = model.Results.Where(x => x.Id == id).FirstOrDefault().UniqueNumber.Replace(".", "");
            }
            if (model.KaskoTables.Count == 0)
            {
                model.KaskoTables.Add(new Kasko());
                model.Results.Add(new FullResult());
            }
            return View(model);
        }

        [HttpGet]
        public ActionResult KaskoExpress()
        {
            var model = new CalcKaskoExpressViewModel();
            return View(model);         
        }

        [HttpGet]
        public JsonResult GetModelsAuto(string modelAuto)
        {
            var modelsAuto = rbsCalcModel.GetArrayByValue("Модель", modelAuto);
            var serializer = new JavaScriptSerializer();
            var result = serializer.Serialize(modelsAuto);
            return Json(result, JsonRequestBehavior.AllowGet);
        }

        public ActionResult ClarifyCalculation(string kaskoExpressData)
        {
            var serializer = new JavaScriptSerializer();
            TempData["kaskoexpressdata"] = serializer.Deserialize<KaskoExpress>(kaskoExpressData);
            return RedirectToAction("Kasko");
        }

        public ActionResult RedirectTo(string objectData, string id)
        {
            TempData["objectdata"] = objectData;
            if (Request.Form["to"] == "kasko")
            {
                return RedirectToAction("Kasko");
            }
            if (string.IsNullOrEmpty(id))
            {
                return RedirectToAction("Osago");
            }
            return RedirectToAction("Osago", new { objectId = id });
        }

        [HttpPost]
        public JsonResult CalcKaskoExpress()
        {
            try
            {
                var sex = Request.Form.Get("sex").Split(new[] { ',' }, StringSplitOptions.RemoveEmptyEntries);
                var age = Request.Form.Get("age").Split(new[] { ',' }, StringSplitOptions.RemoveEmptyEntries);
                var expirience = Request.Form.Get("expirience").Split(new[] { ',' }, StringSplitOptions.RemoveEmptyEntries);
                var married = Request.Form.Get("married").Split(new[] { ',' }, StringSplitOptions.RemoveEmptyEntries);
                var children = Request.Form.Get("children").Split(new[] { ',' }, StringSplitOptions.RemoveEmptyEntries);
                var driversCount = sex.Length;
                var dict = new Dictionary<string, string>
                {
                    {"Марка", Request.Form["brandauto"]},
                    {"Модель", Request.Form["modelauto"]},
                    {"Год выпуска", Request.Form["year"]},
                    {"Допущенные водители", Request.Form["driver"]},
                    {"Страхователь", "Физическое лицо"},
                    {"Регион", "Москва"},
                    {"Руль", "Левый"},
                    {"Гарантия", "Действует"},
                    {"Новое", "Нет"},
                    {"Полный привод", "Нет"},
                    {"Валюта расчета", Request.Form["currency"]},
                    {"Предельный пробег", "40000"},
                    {"Дата начала эксплуатации", Request.Form["year"] + "-01-01"},
                    {"Дата расчета", DateTime.Now.ToString("yyyy-MM-dd")},
                    {"Мощность", Request.Form["power"]},
                    {"Банк", Request.Form["credit"]},                       
                    {"Стоимость ТС", Double.Parse(Request.Form["cost"]).ToString()},           //неизвестен ключ
                    {"ЭПС", Request.Form["signaling"]},
                    {"Иммобилайзер", Request.Form["immo"]}
                };
                if ((age.Length == 0 || expirience.Length == 0) && Request.Form["driver"] == "Ограниченное количество")
                {
                    throw new Exception("Корректно заполните всю информацию о водителях");
                }
                if (driversCount > 0 && Request.Form["driver"] == "Ограниченное количество")
                {
                    dict.Add("Пол водителя", sex[0]);
                    dict.Add("Возраст водителя", age[0]);
                    dict.Add("Стаж водителя", expirience[0]);
                    dict.Add("Наличие брака водителя", married[0]);
                    dict.Add("Количество детей водителя", children[0]);
                    for (var i = 2; i < driversCount + 1; i++)
                    {
                        dict.Add("Пол водителя " + i, sex[i - 1]);
                        dict.Add("Возраст водителя " + i, age[i - 1]);
                        dict.Add("Стаж водителя " + i, expirience[i - 1]);
                        dict.Add("Наличие брака водителя " + i, married[i - 1]);
                        dict.Add("Количество детей водителя " + i, children[i - 1]);
                    }
                }
                if (Request.Form["driver"] == "Неограниченное количество")
                {
                    dict.Add("Минимальный возраст", Request.Form["min-age"]);
                    dict.Add("Минимальный стаж", Request.Form["min-period"]);
                }
                dict.Add("uniquenumber", string.Format("{0}.{1:D4}", DateTime.Now.ToString("ddMMyyyy", CultureInfo.InvariantCulture), rosModel.GetEntities("РасчётСтраховки", CurrentUser.Id).Count + 1));
                var taskId = GetTaskId();
                ProgressManager.SetCompleted(taskId, 50);
                var result = rbsCalcModel.CalcKasko(dict).Where(p => p.kaskoValue > 0).OrderBy(p => p.kaskoValue);
                if (ProgressManager.ShouldTerminate(taskId))
                {
                    ProgressManager.SetCompleted(taskId, 70);
                    return Json("abort");
                }
                // добавление в словарь не участвуемых в расчете полей для сериализации
                dict.Add("Пробег", Request.Form["path"]);
                dict.Add("Единицы пробега", Request.Form["unitpath"]);
                rbsCalcModel.SaveSerializeKaskoExpress(CurrentUser.Id, dict, result.Select(x => new KaskoResult
                {
                    AdditionalConditions = x.additionalConditions,
                    CompanyName = x.companyName,
                    DamageRate = x.damageRate,
                    DamageValue = x.damageValue,
                    Deductible = x.deductible,
                    KaskoRate = x.kaskoRate,
                    KaskoValue = x.kaskoValue,
                    ServiceProgram = x.serviceProgram
                }).ToList());

                ProgressManager.SetCompleted(taskId, 100);
                return Json(result.Select(x => new ExpressResult
                {
                    CompanyName = x.companyName,
                    KaskoRate = x.kaskoRate,
                    KaskoValue = x.kaskoValue,
                    Discount = Convert.ToDouble((x.kaskoRate * x.kaskoValue / 100).ToString(".##"))
                }));
            }
            catch (Exception ex)
            {
                return Json(ex.Message);
            }
        }

        [HttpPost]
        public string CloseTab(string id)
        {
            rosModel.UpdateEntityValue(CurrentUser.Id, "ИсторияРасчетов", rosModel.GetEntityValue<string>(CurrentUser.Id, "ИсторияРасчетов").Replace(id + ";", ""));
            return "ok";
        }

        [HttpPost]
        public string SaveCalculation(string id)
        {
            rosModel.UpdateEntityValue(id, "СохраненРасчет", true);
            /*var kasko = rbsCalcModel.GetCalculationKasko(id);
            var values = new Dictionary<string, object>
                             {
                                 {"НазваниеОбъекта", kasko.CarManufacture + " " + kasko.CarModel + ", " + kasko.Release},
                                 {"ТипОбъектСтрахования", ""},
                                 {"Страхователь", ""},
                                 {"СсылкаНаСтрахователя", 0},
                                 {"КатегорияТС", kasko.CategoryTs},
                                 {"Марка", kasko.CarManufacture},
                                 {"Модель", kasko.CarModel},
                                 {"ГодВыпуска", kasko.Release},
                                 {"ДвигателяОбъем", kasko.Engine},
                                 {"МощностьДвигателя", kasko.Power},
                                 {"Руль", kasko.ControlWheel},
                                 {"КоличествоМест", kasko.Landing},
                                 {"МаксимальнаяМасса", kasko.MaxMass},
                                 {"Грузоподъемность", kasko.Mass},
                                 {"Удален", false}
                             };
            DateTime dateOperation, datePts;
            values.Add("НачалоЭксплуатации",
                       DateTime.TryParse(kasko.BeginningOfOperation, out dateOperation)
                           ? dateOperation
                           : DateTime.MinValue);
            values.Add("ДатаВыдачиПтс", DateTime.TryParse(kasko.Pts, out datePts) ? datePts : DateTime.MinValue);
            cabinetModel.AddObject(CurrentUser.Id, values);*/
            return "ok";
        }

        [HttpPost]
        public JsonResult CalcKasko()
        {
            try
            {
                var sex = Request.Form.Get("sex").Split(new[] { ',' }, StringSplitOptions.RemoveEmptyEntries);
                var age = Request.Form.Get("age").Split(new[] { ',' }, StringSplitOptions.RemoveEmptyEntries);
                var expirience = Request.Form.Get("expirience").Split(new[] { ',' }, StringSplitOptions.RemoveEmptyEntries);
                var married = Request.Form.Get("married").Split(new[] { ',' }, StringSplitOptions.RemoveEmptyEntries);
                var children = Request.Form.Get("children").Split(new[] { ',' }, StringSplitOptions.RemoveEmptyEntries);
                var driversCount = sex.Length;

                var dict = new Dictionary<string, string>
                           {
                               {"Регион", Request.Form["region"]},
                               {"Страхователь", Request.Form["insurant"]},
                               {"Марка", Request.Form["brandauto"]},
                               {"Модель", Request.Form["modelauto"]},
                               {"Год выпуска", Request.Form["year"]},
                               {"Новое", Request.Form["statets"]},
                               {"Дата расчета", DateTime.Now.ToString("yyyy-MM-dd")},
                               {"Гарантия", Request.Form["guarantee"]},
                               {"Мощность", Request.Form["power"]},
                               {"Кредит", Request.Form["credit"]},                         
                               {"Стоимость ТС", Double.Parse(Request.Form["cost"]).ToString()},              
                               {"Валюта расчета",Request.Form["currency"] }, 
                               {"Франшиза в рублях", Request.Form["FranshizaInRub"]},
                               {"Франшиза в процентах", Request.Form["FranshizaInProc"]},
                               {"Форма возмещения", Request.Form["compensation"]},
                               {"Масса", Request.Form["maxmass"]},
                               {"Оплата", Request.Form["payment"]},
                               {"Срок страхования", Request.Form["InsurancePeriod"]},
                               {"Переход", Request.Form["transition"]},
                               {"Условия хранения", Request.Form["storagecondition"]},
                               {"Предельный пробег", Request.Form["maxpath"]},
                               {"Количество ТС", Request.Form["quantity"]},                         
                               {"Руль", Request.Form["ControlWheel"]},
                               {"ЭПС", Request.Form["signaling"]},
                               {"ЭПС с автозапуском", Request.Form["autostart"]},
                               {"Метка", Request.Form["siglabel"]},
                               {"МПУ", Request.Form["mpu"]},
                               {"Иммобилайзер", Request.Form["immo"]},
                               {"Противоугонный комплекс", Request.Form["siganticreep"]},
                               {"ОПС", Request.Form["sigantidamping"]}                         
                           };

                if (!string.IsNullOrEmpty(Request.Form["beginoperation"]))
                {
                    DateTime date;
                    if (DateTime.TryParse(Request.Form["beginoperation"], CultureInfo.CreateSpecificCulture("ru-RU"), DateTimeStyles.None, out date))
                    {
                        dict.Add("Дата начала эксплуатации", date.ToString("yyyy-MM-dd"));
                    }
                    else
                    {
                        throw new Exception("Неверно заполнено поле \"Начало эксплуатации\"");
                    }
                }
                else
                {
                    dict.Add("Дата начала эксплуатации", string.Empty);
                }

                if ((age.Length == 0 || expirience.Length == 0) && Request.Form["driver"] == "Ограниченное количество")
                {
                    throw new Exception("Корректно заполните всю информацию в разделе \"Сведения о водителях\"");
                }
                var driver = Request.Form.Get("driver");
                dict.Add("Допущенные водители", Request.Form.Get("driver"));
                switch (driver)
                {
                    case "Ограниченное количество":
                        dict.Add("Пол водителя", sex[0]);
                        dict.Add("Возраст водителя", age[0]);
                        dict.Add("Стаж водителя", expirience[0]);
                        dict.Add("Наличие брака водителя", married[0]);
                        dict.Add("Количество детей водителя", children[0]);
                        for (var i = 2; i < driversCount + 1; i++)
                        {
                            dict.Add("Пол водителя " + i, sex[i - 1]);
                            dict.Add("Возраст водителя " + i, age[i - 1]);
                            dict.Add("Стаж водителя " + i, expirience[i - 1]);
                            dict.Add("Наличие брака водителя " + i, married[i - 1]);
                            dict.Add("Количество детей водителя " + i, children[i - 1]);
                        }
                        break;
                    case "Неограниченное количество":
                        dict.Add("Минимальный возраст", Request.Form["min-age"]);
                        dict.Add("Минимальный стаж", Request.Form["min-period"]);
                        break;
                }
                var jsonResult = new FullResult();
                var taskId = GetTaskId();
                ProgressManager.SetCompleted(taskId, 50);
                jsonResult.Results = rbsCalcModel.CalcKasko(dict).Where(p => p.kaskoValue > 0).OrderBy(p => p.kaskoValue).Select(
                        x =>
                        new KaskoResult
                            {
                                AdditionalConditions = x.additionalConditions,
                                CompanyName = x.companyName,
                                DamageRate = x.damageRate,
                                DamageValue = x.damageValue,
                                Deductible = x.deductible,
                                KaskoRate = x.kaskoRate,
                                KaskoValue = x.kaskoValue,
                                ServiceProgram = x.serviceProgram
                            }).ToList();
                jsonResult.UniqueNumber = string.Format("{0}.{1:D4}", DateTime.Now.ToString("ddMMyy", CultureInfo.InvariantCulture), rosModel.GetEntities("РасчётСтраховки", CurrentUser.Id).Count + 1);
                jsonResult.DateTimeCalc = DateTime.Now.ToString("от dd MMMM, HH:mm");
                //добавление в словарь неиспользуемых в расчете полей для сериализации
                dict.Add("uniquenumber", jsonResult.UniqueNumber);
                dict.Add("Собственник ТС", Request.Form["owner"]);
                dict.Add("Категория ТС", Request.Form["category"]);
                dict.Add("Риск", Request.Form["risk"]);
                dict.Add("Лимит ответственности", Request.Form["limit"]);
                dict.Add("Дата выдачи ПТС", Request.Form["pts"]);
                dict.Add("Пробег", Request.Form["path"]);
                dict.Add("Единицы пробега", Request.Form["unitpath"]);
                dict.Add("Объем двигателя", Request.Form["engine"]);
                dict.Add("Единицы предельного пробега", Request.Form["unitmaxpath"]);
                dict.Add("Количество мест", Request.Form["landing"]);
                dict.Add("Грузоподъемность", Request.Form["mass"]);
                dict.Add("Дополнительная ЭПС", Request.Form["signalingadd"]);
                if (ProgressManager.ShouldTerminate(taskId))
                {
                    ProgressManager.SetCompleted(taskId, 70);
                    return Json("abort");
                }
                jsonResult.Id = rbsCalcModel.SaveSerializeKasko(CurrentUser.Id, dict, jsonResult.Results);
                rosModel.UpdateEntityValue(CurrentUser.Id, "ИсторияРасчетов", string.Format("{0}{1};", rosModel.GetEntityValue<string>(CurrentUser.Id, "ИсторияРасчетов"), jsonResult.Id));
                if (ProgressManager.ShouldTerminate(taskId))
                {
                    ProgressManager.SetCompleted(taskId, 70);
                    return Json("abort");
                }
                ProgressManager.SetCompleted(taskId, 100);
                return Json(jsonResult);
            }
            catch (Exception ex)
            {
                return Json(ex.Message);
            }

        }
        [HttpPost]
        public string GetCostCar(string manufacture, string model, string release)
        {
            return rbsCalcModel.GetAverageCost(manufacture, model, release);
        }

        public void GetPdf(string id)
        {
            var m = new MemoryStream();
            var document = new Document(PageSize.A4);
            try
            {
                Response.ContentType = "application/pdf";
                var writer = PdfWriter.GetInstance(document, m);
                writer.CloseStream = false;
                pdfModel.GetPdfDocument(id, document, writer);
            }
            catch (DocumentException ex)
            {
                Console.Error.WriteLine(ex.StackTrace);
                Console.Error.WriteLine(ex.Message);
            }

            document.Close();
            Response.OutputStream.Write(m.GetBuffer(), 0, m.GetBuffer().Length);
            Response.OutputStream.Flush();
            Response.OutputStream.Close();
            m.Close();
        }

        [HttpGet]
        public ActionResult Osago(string objectId)
        {
            var model = new CalcOsagoViewModel();
            if (!string.IsNullOrEmpty(objectId))
            {
                model.ObjectId = objectId;
                model.ObjectName = rosModel.GetEntityValue<string>(model.ObjectId, "НазваниеОбъекта");
            }
            var serialize = new JavaScriptSerializer();
            model.Companies = serialize.Serialize(rbsCalcModel.GetCompaniesWithOsago());
            model.Objects = clientsModel.GetObjects(CurrentUser.Id, "atwork");
            return View(model);
        }

        [HttpPost]
        public JsonResult CalcOsago()
        {
            using (var calc = new CalcOsagoModel())
            {
                bool isFis = Request.Form.Get("owner").Contains("Физическое лицо");
                bool isБезограничений = Request.Form.Get("drivers").Contains("Неограниченное");
                /* Не используются следующие поля формы:
                 1 ТС зарегистрированно в иностранном государстве 
                 2 ТС следует к месту регистрации 
                 3 Класс водителя
                 */
                try
                {
                    int minAge, minExp, power, userPeriod, minKbm;
                    int.TryParse(Request.Form.Get("min-age"), out minAge);
                    int.TryParse(Request.Form.Get("min-period"), out minExp);
                    int.TryParse(Request.Form.Get("power"), out power);
                    int.TryParse(Request.Form.Get("klassdrive"), out minKbm);
                    if (Request.Form.Get("placeregister") != null)
                    {
                        int.TryParse(Request.Form.Get("placeregister"), out userPeriod);
                    }
                    else
                    {
                        int.TryParse(Request.Form.Get("useperiod"), out userPeriod);
                    }
                    // Объект для сериализации
                    var objSerialize = new Osago
                                           {
                                               OwnerTs = isFis ? "Физическое лицо" : "Юридическое лицо",
                                               Drivers = isБезограничений ? "Неограниченное" : "Ограниченное",
                                               MinAge = isБезограничений ? 0 : minAge,
                                               MinPeriod = isБезограничений ? 0 : minExp,
                                               CategoryTs = Request.Form.Get("category"),
                                               Power = power,
                                               RegionId = Request.Form.Get("region"),
                                               RegionName = rosModel.GetEntityValue<string>(Request.Form.Get("region"), "НазваниеОбъекта"),
                                               MinKbm = minKbm,
                                               ClassDriver = Request.Form.Get("klassdrive"),
                                               ToPlaceRegister = Request.Form.AllKeys.Contains("placeregister"),
                                               RegisterInForeign = Request.Form.AllKeys.Contains("registerinforeign"),
                                               UsePeriod = Request.Form.AllKeys.Contains("placeregister") ? 0 : userPeriod,
                                               UniqueNumber = string.Format("{0}.{1:D4}", DateTime.Now.ToString("ddMMyy", CultureInfo.InvariantCulture), rosModel.GetEntities("РасчётСтраховки", CurrentUser.Id).Count + 1)
                                           };//


                    var cost = calc.CalcСтраховаяПремия(
                        isFis,
                        (CalcOsagoModel.КатегорияТС)Enum.Parse(typeof(CalcOsagoModel.КатегорияТС), Request.Form.Get("category")),
                        Request.Form.Get("region"),
                        isБезограничений,
                        minAge,
                        minExp,
                        power,
                        userPeriod,
                        minKbm);
                    var res = new string[2];
                    res[0] = string.Format(@"<td>{0}</td><td>{1}</td><td>{2}</td><td>{4}</td><td>{3}</td><td>{5}</td><td>{6}</td><td>{7}</td><td class='row-nowrap'>{8}</td>",
                                            calc.Тб,
                                            calc.Кт,
                                            calc.Кбм,
                                            calc.Квс,
                                            calc.Ко,
                                            calc.Км,
                                            calc.Кп,
                                            calc.Кс,
                                            cost.ToString("N2"));
                    // Объект для сериализации
                    objSerialize.Result.Ko = calc.Ко;
                    objSerialize.Result.InsurancePremium = cost > 0 ? Double.Parse(cost.ToString("#.###")) : 0;
                    objSerialize.Result.Kbm = calc.Кбм;
                    objSerialize.Result.Km = calc.Км;
                    objSerialize.Result.Kp = calc.Кп;
                    objSerialize.Result.Ks = calc.Кс;
                    objSerialize.Result.Kt = calc.Кт;
                    objSerialize.Result.Kvs = calc.Квс;
                    objSerialize.Result.Tb = calc.Тб; //
                    res[1] = calc.SaveSerializeOsago(CurrentUser.Id, Request.Form.Get("objectid"), objSerialize, Request.Form.Get("objectname"));
                    return Json(res);
                }
                catch (Exception ex)
                {
                    return Json(ex.Message);
                }
            }
        }

        [HttpPost]
        public string SaveCalculationOsago(string companyId, string calcId, string companyName)
        {
            rosModel.UpdateEntityValue(calcId, "СохраненРасчет", true);
            var values = new Dictionary<string, object>();
            values.Add("НазваниеОбъекта", companyName);
            values.Add("СсылкаНаКомпанию", string.IsNullOrEmpty(companyId) ? 0M : Convert.ToDecimal(companyId));
            return Url.Action("OsagoResult", "Cabinet", new { id = rosModel.AddEntity(calcId, "ПодтвержденныйРасчетОсаго", values)});            
        }
    }
}
